var runtime.gcController
152 uses
runtime (current package)
arena.go#L883: gcController.heapInUse.add(-int64(s.npages * pageSize))
arena.go#L889: gcController.totalFree.Add(int64(s.elemsize))
arena.go#L903: gcController.update(-int64(s.elemsize), 0)
arena.go#L1047: sysMap(unsafe.Pointer(base), userArenaChunkBytes, &gcController.heapReleased, "user arena chunk")
arena.go#L1073: gcController.heapInUse.add(int64(userArenaChunkBytes))
arena.go#L1074: gcController.heapReleased.add(-int64(userArenaChunkBytes))
arena.go#L1086: gcController.totalAlloc.Add(int64(s.elemsize))
arena.go#L1089: gcController.update(int64(s.elemsize), 0)
malloc.go#L633: gcController.memoryLimit.Store(math.MaxInt64)
malloc.go#L662: v = h.arena.alloc(n, heapArenaBytes, &gcController.heapReleased, "heap")
mcache.go#L177: gcController.totalAlloc.Add(bytesAllocated)
mcache.go#L214: gcController.update(int64(s.npages*pageSize)-int64(usedBytes), int64(c.scanAlloc))
mcache.go#L248: gcController.totalAlloc.Add(int64(npages * pageSize))
mcache.go#L251: gcController.update(int64(s.npages*pageSize), 0)
mcache.go#L289: gcController.totalAlloc.Add(slotsUsed * int64(s.elemsize))
mcache.go#L316: gcController.update(dHeapLive, scanAlloc)
mem.go#L51: gcController.mappedReady.Add(int64(n))
mem.go#L69: gcController.mappedReady.Add(-int64(n))
mem.go#L84: gcController.mappedReady.Add(int64(prepared))
mem.go#L130: gcController.mappedReady.Add(-int64(n))
mem.go#L144: gcController.mappedReady.Add(-int64(n))
metrics.go#L283: out.scalar = uint64(gcController.memoryLimit.Load())
metrics.go#L289: out.scalar = uint64(gcController.gcPercent.Load())
metrics.go#L296: out.scalar = gcController.heapMarked
metrics.go#L652: a.heapGoal = gcController.heapGoal()
metrics.go#L693: a.heapScan = gcController.heapScan.Load()
metrics.go#L694: a.stackScan = gcController.lastStackScan.Load()
metrics.go#L695: a.globalsScan = gcController.globalsScan.Load()
mgc.go#L189: gcController.init(readGOGC(), readGOMEMLIMIT())
mgc.go#L312: delta := now - gcController.markStartTime
mgc.go#L320: return float64(selfTime)/float64(delta) > 1.2*gcController.fractionalUtilizationGoal
mgc.go#L622: trigger, _ := gcController.trigger()
mgc.go#L623: return gcController.heapLive.Load() >= trigger
mgc.go#L625: if gcController.gcPercent.Load() < 0 {
mgc.go#L736: work.heap0 = gcController.heapLive.Load()
mgc.go#L763: gcController.startCycle(now, int(gomaxprocs), trigger)
mgc.go#L1029: gcController.endCycle(now, int(gomaxprocs), work.userForced)
mgc.go#L1041: work.heap1 = gcController.heapLive.Load()
mgc.go#L1101: memstats.lastHeapInUse = gcController.heapInUse.load()
mgc.go#L1273: gcController.assistTime.Load(),
mgc.go#L1274: gcController.dedicatedMarkTime.Load() + gcController.fractionalMarkTime.Load(),
mgc.go#L1275: gcController.idleMarkTime.Load(),
mgc.go#L1288: gcController.lastHeapGoal>>20, " MB goal, ",
mgc.go#L1289: gcController.lastStackScan.Load()>>20, " MB stacks, ",
mgc.go#L1290: gcController.globalsScan.Load()>>20, " MB globals, ",
mgc.go#L1326: if gcController.heapGoal() > minHeapForMetadataHugePages {
mgc.go#L1568: gcController.markWorkerStop(pp.gcMarkWorkerMode, duration)
mgc.go#L1706: gcController.resetLive(work.bytesMarked)
mgc.go#L1799: work.initialHeapLive = gcController.heapLive.Load()
mgcmark.go#L169: workCounter = &gcController.globalsScanWork
mgcmark.go#L175: workCounter = &gcController.globalsScanWork
mgcmark.go#L205: workCounter = &gcController.stackScanWork
mgcmark.go#L505: assistWorkPerByte := gcController.assistWorkPerByte.Load()
mgcmark.go#L506: assistBytesPerWork := gcController.assistBytesPerWork.Load()
mgcmark.go#L520: bgScanCredit := gcController.bgScanCredit.Load()
mgcmark.go#L530: gcController.bgScanCredit.Add(-stolen)
mgcmark.go#L700: assistBytesPerWork := gcController.assistBytesPerWork.Load()
mgcmark.go#L727: gcController.assistTime.Add(pp.gcAssistTime)
mgcmark.go#L765: if gcController.bgScanCredit.Load() > 0 {
mgcmark.go#L794: gcController.bgScanCredit.Add(scanWork)
mgcmark.go#L798: assistBytesPerWork := gcController.assistBytesPerWork.Load()
mgcmark.go#L832: assistWorkPerByte := gcController.assistWorkPerByte.Load()
mgcmark.go#L834: gcController.bgScanCredit.Add(scanWork)
mgcmark.go#L1215: gcController.enlistWorker()
mgcmark.go#L1270: gcController.enlistWorker()
mgcmark.go#L1278: gcController.heapScanWork.Add(gcw.heapScanWork)
mgcmark.go#L1298: gcController.heapScanWork.Add(gcw.heapScanWork)
mgcmark.go#L1372: gcController.heapScanWork.Add(gcw.heapScanWork)
mgcmark.go#L1381: gcController.enlistWorker()
mgcpacer.go#L90: var gcController gcControllerState
mgcpacer.go#L462: " (scan ", gcController.heapScan.Load()>>20, " MB in ",
mgcpacer.go#L603: gcController.lastHeapGoal = c.heapGoal()
mgcpacer.go#L898: live := gcController.heapLive.Add(dHeapLive)
mgcpacer.go#L909: gcController.heapScan.Add(dHeapScan)
mgcpacer.go#L1297: out = gcController.setGCPercent(in)
mgcpacer.go#L1344: out = gcController.setMemoryLimit(in)
mgcpacer.go#L1462: gcController.commit(isSweepDone())
mgcpacer.go#L1466: gcController.revise()
mgcpacer.go#L1477: trigger, heapGoal := gcController.trigger()
mgcpacer.go#L1479: gcPaceScavenger(gcController.memoryLimit.Load(), heapGoal, gcController.lastHeapGoal)
mgcscavenge.go#L151: return gcController.heapInUse.load() + gcController.heapFree.load()
mgcscavenge.go#L179: mappedReady := gcController.mappedReady.Load()
mgcscavenge.go#L408: gcController.mappedReady.Load() <= scavenge.memoryLimitGoal.Load()
mgcscavenge.go#L706: gcController.heapReleased.load()>>10, " KiB now, ",
mgcscavenge.go#L707: (gcController.heapInUse.load()*100)/heapRetained(), "% util",
mgcscavenge.go#L783: gcController.heapReleased.add(nbytes)
mgcscavenge.go#L784: gcController.heapFree.add(-nbytes)
mgcsweep.go#L177: live := gcController.heapLive.Load()
mgcsweep.go#L777: gcController.totalFree.Add(int64(nfreed) * int64(s.elemsize))
mgcsweep.go#L813: gcController.totalFree.Add(int64(size))
mgcsweep.go#L927: live := gcController.heapLive.Load()
mgcsweep.go#L993: heapLiveBasis := gcController.heapLive.Load()
mgcwork.go#L190: gcController.enlistWorker()
mgcwork.go#L243: gcController.enlistWorker()
mgcwork.go#L333: gcController.heapScanWork.Add(w.heapScanWork)
mgcwork.go#L361: gcController.enlistWorker()
mheap.go#L1330: if limit := gcController.memoryLimit.Load(); !gcCPULimiter.limiting() {
mheap.go#L1333: inuse := gcController.mappedReady.Load()
mheap.go#L1405: gcController.heapReleased.add(-int64(scav))
mheap.go#L1408: gcController.heapFree.add(-int64(nbytes - scav))
mheap.go#L1410: gcController.heapInUse.add(int64(nbytes))
mheap.go#L1568: inUse := gcController.heapFree.load() + gcController.heapReleased.load() + gcController.heapInUse.load()
mheap.go#L1585: sysMap(unsafe.Pointer(h.curArena.base), size, &gcController.heapReleased, "heap")
mheap.go#L1616: sysMap(unsafe.Pointer(v), nBase-v, &gcController.heapReleased, "heap")
mheap.go#L1730: gcController.heapFree.add(int64(nbytes))
mheap.go#L1732: gcController.heapInUse.add(-int64(nbytes))
mstats.go#L438: totalMapped := gcController.heapInUse.load() + gcController.heapFree.load() + gcController.heapReleased.load() +
mstats.go#L443: heapGoal := gcController.heapGoal()
mstats.go#L465: if gcController.heapInUse.load() != uint64(consStats.inHeap) {
mstats.go#L466: print("runtime: heapInUse=", gcController.heapInUse.load(), "\n")
mstats.go#L470: if gcController.heapReleased.load() != uint64(consStats.released) {
mstats.go#L471: print("runtime: heapReleased=", gcController.heapReleased.load(), "\n")
mstats.go#L475: heapRetained := gcController.heapInUse.load() + gcController.heapFree.load()
mstats.go#L482: if gcController.totalAlloc.Load() != totalAlloc {
mstats.go#L483: print("runtime: totalAlloc=", gcController.totalAlloc.Load(), "\n")
mstats.go#L487: if gcController.totalFree.Load() != totalFree {
mstats.go#L488: print("runtime: totalFree=", gcController.totalFree.Load(), "\n")
mstats.go#L495: if gcController.mappedReady.Load() != totalMapped-uint64(consStats.released) {
mstats.go#L496: print("runtime: mappedReady=", gcController.mappedReady.Load(), "\n")
mstats.go#L514: stats.HeapSys = gcController.heapInUse.load() + gcController.heapFree.load() + gcController.heapReleased.load()
mstats.go#L531: stats.HeapIdle = gcController.heapFree.load() + gcController.heapReleased.load()
mstats.go#L532: stats.HeapInuse = gcController.heapInUse.load()
mstats.go#L533: stats.HeapReleased = gcController.heapReleased.load()
mstats.go#L949: markAssistCpu = gcController.assistTime.Load()
mstats.go#L950: markDedicatedCpu = gcController.dedicatedMarkTime.Load()
mstats.go#L951: markFractionalCpu = gcController.fractionalMarkTime.Load()
mstats.go#L952: markIdleCpu = gcController.idleMarkTime.Load()
proc.go#L3421: gp, tnow := gcController.findRunnableGCWorker(pp, now)
proc.go#L3532: if gcBlackenEnabled != 0 && gcMarkWorkAvailable(pp) && gcController.addIdleMarkWorker() {
proc.go#L3546: gcController.removeIdleMarkWorker()
proc.go#L3936: if atomic.Load(&gcBlackenEnabled) == 0 || !gcController.needIdleMarkWorker() {
proc.go#L3968: if gcBlackenEnabled == 0 || !gcController.addIdleMarkWorker() {
proc.go#L3978: gcController.removeIdleMarkWorker()
proc.go#L4457: gcController.addScannableStack(pp, -int64(gp.stack.hi-gp.stack.lo))
proc.go#L4480: assistWorkPerByte := gcController.assistWorkPerByte.Load()
proc.go#L4482: gcController.bgScanCredit.Add(scanCredit)
proc.go#L5243: gcController.addScannableStack(pp, int64(newg.stack.hi-newg.stack.lo))
stack.go#L912: gcController.addScannableStack(getg().m.p.ptr(), int64(newsize)-int64(old.hi-old.lo))
symtab.go#L547: gcController.addGlobals(int64(scanDataSize + scanBSSSize))
traceruntime.go#L576: heapGoal := gcController.heapGoal()
traceruntime.go#L579: if heapGoal == ^uint64(0) || gcController.gcPercent.Load() < 0 {